/**
 * @Author: Caven
 * @Date: 2021-01-30 22:41:41
 */

const EARTH_RADIUS = 6370996.81;
const MC_BAND = [12890594.86, 8362377.87, 5591021, 3481989.83, 1678043.12, 0];
const LL_BAND = [75, 60, 45, 30, 15, 0];
const MC2LL = [
    [1.410526172116255e-8, 8.98305509648872e-6, -1.9939833816331, 2.009824383106796e2, -1.872403703815547e2, 91.6087516669843, -23.38765649603339, 2.57121317296198, -0.03801003308653, 1.73379812e7],
    [-7.435856389565537e-9, 8.983055097726239e-6, -0.78625201886289, 96.32687599759846, -1.85204757529826, -59.36935905485877, 47.40033549296737, -16.50741931063887, 2.28786674699375, 1.026014486e7],
    [-3.030883460898826e-8, 8.98305509983578e-6, 0.30071316287616, 59.74293618442277, 7.357984074871, -25.38371002664745, 13.45380521110908, -3.29883767235584, 0.32710905363475, 6.85681737e6],
    [-1.981981304930552e-8, 8.983055099779535e-6, 0.03278182852591, 40.31678527705744, 0.65659298677277, -4.44255534477492, 0.85341911805263, 0.12923347998204, -0.04625736007561, 4.48277706e6],
    [3.09191371068437e-9, 8.983055096812155e-6, 0.00006995724062, 23.10934304144901, -0.00023663490511, -0.6321817810242, -0.00663494467273, 0.03430082397953, -0.00466043876332, 2.5551644e6],
    [2.890871144776878e-9, 8.983055095805407e-6, -0.00000003068298, 7.47137025468032, -0.00000353937994, -0.02145144861037, -0.00001234426596, 0.00010322952773, -0.00000323890364, 8.260885e5],
];
const LL2MC = [
    [
        -0.0015702102444, 1.113207020616939e5, 1.704480524535203e15, -1.033898737604234e16, 2.611266785660388e16, -3.51496691766537e16, 2.659570071840392e16, -1.072501245418824e16,
        1.800819912950474e15, 82.5,
    ],
    [
        8.277824516172526e-4, 1.113207020463578e5, 6.477955746671608e8, -4.082003173641316e9, 1.077490566351142e10, -1.517187553151559e10, 1.205306533862167e10, -5.124939663577472e9,
        9.133119359512032e8, 67.5,
    ],
    [0.00337398766765, 1.113207020202162e5, 4.481351045890365e6, -2.339375119931662e7, 7.968221547186455e7, -1.159649932797253e8, 9.723671115602145e7, -4.366194633752821e7, 8.477230501135234e6, 52.5],
    [0.00220636496208, 1.113207020209128e5, 5.175186112841131e4, 3.796837749470245e6, 9.920137397791013e5, -1.22195221711287e6, 1.340652697009075e6, -6.209436990984312e5, 1.444169293806241e5, 37.5],
    [
        -3.441963504368392e-4, 1.113207020576856e5, 2.782353980772752e2, 2.485758690035394e6, 6.070750963243378e3, 5.482118345352118e4, 9.540606633304236e3, -2.71055326746645e3, 1.405483844121726e3,
        22.5,
    ],
    [-3.218135878613132e-4, 1.113207020701615e5, 0.00369383431289, 8.237256402795718e5, 0.46104986909093, 2.351343141331292e3, 1.58060784298199, 8.77738589078284, 0.37238884252424, 7.45],
];

class BaiduMercatorProjection {
    constructor() {
        this.isWgs84 = false;
    }

    /**
     *
     * @param point1
     * @param point2
     * @returns {number}
     */
    getDistanceByMC(point1, point2) {
        if (!point1 || !point2) {
            return 0;
        }
        point1 = this.convertMC2LL(point1);
        if (!point1) {
            return 0;
        }
        let x1 = this.toRadians(point1["lng"]);
        let y1 = this.toRadians(point1["lat"]);
        point2 = this.convertMC2LL(point2);
        if (!point2) {
            return 0;
        }
        let x2 = this.toRadians(point2["lng"]);
        let y2 = this.toRadians(point2["lat"]);
        return this.getDistance(x1, x2, y1, y2);
    }

    /**
     * Calculate the distance between two points according to the latitude and longitude coordinates
     * @param point1
     * @param point2
     * @returns {number|*}
     */
    getDistanceByLL(point1, point2) {
        if (!point1 || !point2) {
            return 0;
        }
        point1["lng"] = this.getLoop(point1["lng"], -180, 180);
        point1["lat"] = this.getRange(point1["lat"], -74, 74);
        point2["lng"] = this.getLoop(point2["lng"], -180, 180);
        point2["lat"] = this.getRange(point2["lat"], -74, 74);
        let x1 = this.toRadians(point1["lng"]);
        let y1 = this.toRadians(point1["lat"]);
        let x2 = this.toRadians(point2["lng"]);
        let y2 = this.toRadians(point2["lat"]);
        return this.getDistance(x1, x2, y1, y2);
    }

    /**
     * The plane cartesian coordinates are converted to latitude and longitude coordinates
     * @param point
     * @returns {Point|{lng: number, lat: number}}
     */
    convertMC2LL(point) {
        if (!point) {
            return { lng: 0, lat: 0 };
        }
        let lnglat = {};
        if (this.isWgs84) {
            lnglat.lng = (point.lng / 20037508.34) * 180;
            let mmy = (point.lat / 20037508.34) * 180;
            lnglat.lat = (180 / Math.PI) * (2 * Math.atan(Math.exp((mmy * Math.PI) / 180)) - Math.PI / 2);
            return {
                lng: lnglat["lng"].toFixed(6),
                lat: lnglat["lat"].toFixed(6),
            };
        }

        let temp = {
            lng: Math.abs(point["lng"]),
            lat: Math.abs(point["lat"]),
        };

        let factor = undefined;
        for (let i = 0; i < MC_BAND.length; i++) {
            if (temp["lat"] >= MC_BAND[i]) {
                factor = MC2LL[i];
                break;
            }
        }
        lnglat = this.convertor(point, factor);
        return {
            lng: lnglat["lng"].toFixed(6),
            lat: lnglat["lat"].toFixed(6),
        };
    }

    /**
     * The latitude and longitude coordinates are converted to plane cartesian coordinates
     * @param point
     * @returns {{lng: number, lat: number}|*}
     */
    convertLL2MC(point) {
        if (!point) {
            return { lng: 0, lat: 0 };
        }
        if (point["lng"] > 180 || point["lng"] < -180 || point["lat"] > 90 || point["lat"] < -90) {
            return point;
        }

        if (this.isWgs84) {
            let mercator = {};
            let earthRad = 6378137.0;
            mercator.lng = ((point.lng * Math.PI) / 180) * earthRad;
            let a = (point.lat * Math.PI) / 180;
            mercator.lat = (earthRad / 2) * Math.log((1.0 + Math.sin(a)) / (1.0 - Math.sin(a)));

            return {
                lng: parseFloat(mercator["lng"].toFixed(2)),
                lat: parseFloat(mercator["lat"].toFixed(2)),
            };
        }

        point["lng"] = this.getLoop(point["lng"], -180, 180);
        point["lat"] = this.getRange(point["lat"], -74, 74);
        let temp = { lng: point["lng"], lat: point["lat"] };
        let factor = undefined;
        for (let i = 0; i < LL_BAND.length; i++) {
            if (temp["lat"] >= LL_BAND[i]) {
                factor = LL2MC[i];
                break;
            }
        }
        if (!factor) {
            for (let i = 0; i < LL_BAND.length; i++) {
                if (temp["lat"] <= -LL_BAND[i]) {
                    factor = LL2MC[i];
                    break;
                }
            }
        }
        let mc = this.convertor(point, factor);
        return {
            lng: parseFloat(mc["lng"].toFixed(2)),
            lat: parseFloat(mc["lat"].toFixed(2)),
        };
    }

    /**
     *
     * @param fromPoint
     * @param factor
     * @returns {{lng: *, lat: *}}
     */
    convertor(fromPoint, factor) {
        if (!fromPoint || !factor) {
            return { lng: 0, lat: 0 };
        }
        let x = factor[0] + factor[1] * Math.abs(fromPoint["lng"]);
        let temp = Math.abs(fromPoint["lat"]) / factor[9];
        let y =
            factor[2] +
            factor[3] * temp +
            factor[4] * temp * temp +
            factor[5] * temp * temp * temp +
            factor[6] * temp * temp * temp * temp +
            factor[7] * temp * temp * temp * temp * temp +
            factor[8] * temp * temp * temp * temp * temp * temp;
        x *= fromPoint["lng"] < 0 ? -1 : 1;
        y *= fromPoint["lat"] < 0 ? -1 : 1;
        return {
            lng: x,
            lat: y,
        };
    }

    /**
     *
     * @param x1
     * @param x2
     * @param y1
     * @param y2
     * @returns {number}
     */
    getDistance(x1, x2, y1, y2) {
        return EARTH_RADIUS * Math.acos(Math.sin(y1) * Math.sin(y2) + Math.cos(y1) * Math.cos(y2) * Math.cos(x2 - x1));
    }

    /**
     *
     * @param deg
     * @returns {number}
     */
    toRadians(deg) {
        return (Math.PI * deg) / 180;
    }

    /**
     *
     * @param rad
     * @returns {number}
     */
    toDegrees(rad) {
        return (180 * rad) / Math.PI;
    }

    /**
     *
     * @param v
     * @param a
     * @param b
     * @returns {number}
     */
    getRange(v, a, b) {
        if (a != null) {
            v = Math.max(v, a);
        }
        if (b != null) {
            v = Math.min(v, b);
        }
        return v;
    }

    /**
     *
     * @param v
     * @param a
     * @param b
     * @returns {*}
     */
    getLoop(v, a, b) {
        while (v > b) {
            v -= b - a;
        }
        while (v < a) {
            v += b - a;
        }
        return v;
    }

    /**
     *
     * @param point
     * @returns {{lng: number, lat: number}|*}
     */
    lngLatToMercator(point) {
        return this.convertLL2MC(point);
    }

    /**
     *
     * @param point
     * @returns {{x: (number|*), y: (number|*)}}
     */
    lngLatToPoint(point) {
        let mercator = this.convertLL2MC(point);
        return {
            x: mercator["lng"],
            y: mercator["lat"],
        };
    }

    /**
     * WebMercator transforms to latitude and longitude
     * @param point
     * @returns {Point|{lng: number, lat: number}}
     */
    mercatorToLngLat(point) {
        return this.convertMC2LL(point);
    }

    /**
     *
     * @param point
     * @returns {Point|{lng: number, lat: number}}
     */
    pointToLngLat(point) {
        let mercator = { lng: point.x, lat: point.y };
        return this.convertMC2LL(mercator);
    }

    /**
     * Latitude and longitude coordinates  transforms to  pixel coordinates
     * @param point
     * @param zoom
     * @param mapCenter
     * @param mapSize
     * @returns {{x: number, y: number}}
     */
    pointToPixel(point, zoom, mapCenter, mapSize) {
        if (!point) {
            return { x: 0, y: 0 };
        }
        point = this.lngLatToMercator(point);
        let zoomUnits = this.getZoomUnits(zoom);
        let x = Math.round((point["lng"] - mapCenter["lng"]) / zoomUnits + mapSize.width / 2);
        let y = Math.round((mapCenter["lat"] - point["lat"]) / zoomUnits + mapSize.height / 2);
        return { x, y };
    }

    /**
     * Pixel coordinates transforms to latitude and longitude coordinates
     * @param pixel
     * @param zoom
     * @param mapCenter
     * @param mapSize
     * @returns {Point|{lng: number, lat: number}}
     */
    pixelToPoint(pixel, zoom, mapCenter, mapSize) {
        if (!pixel) {
            return { lng: 0, lat: 0 };
        }
        let zoomUnits = this.getZoomUnits(zoom);
        let lng = mapCenter["lng"] + zoomUnits * (pixel.x - mapSize.width / 2);
        let lat = mapCenter["lat"] - zoomUnits * (pixel.y - mapSize.height / 2);
        let point = { lng, lat };
        return this.mercatorToLngLat(point);
    }

    /**
     *
     * @param zoom
     * @returns {number}
     */
    getZoomUnits(zoom) {
        return Math.pow(2, 18 - zoom);
    }
}

export default BaiduMercatorProjection;
